#include"dao_gsl_sorting.h"

DAO_INIT_MODULE;
DaoVmSpace *__daoVmSpace = NULL;

#ifdef __cplusplus
extern "C"{
#endif

static DaoNumItem constNumbers[] =
{

  { NULL, 0, 0 }
};
static void dao__gsl_sort_char( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_char_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_char_smallest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_char_smallest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_char_largest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_char_largest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_smallest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_smallest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_largest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_largest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_float( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_float_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_float_smallest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_float_smallest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_float_largest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_float_largest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_int( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_int_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_int_smallest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_int_smallest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_int_largest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_int_largest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_long( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_long_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_long_smallest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_long_smallest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_long_largest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_long_largest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_long_double( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_long_double_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_long_double_smallest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_long_double_smallest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_long_double_largest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_long_double_largest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_short( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_short_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_short_smallest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_short_smallest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_short_largest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_short_largest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_uchar( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_uchar_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_uchar_smallest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_uchar_smallest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_uchar_largest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_uchar_largest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_uint( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_uint_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_uint_smallest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_uint_smallest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_uint_largest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_uint_largest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_ulong( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_ulong_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_ulong_smallest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_ulong_smallest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_ulong_largest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_ulong_largest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_ushort( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_ushort_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_ushort_smallest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_ushort_smallest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_ushort_largest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_ushort_largest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_char( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_char_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_char_smallest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_char_largest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_char_smallest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_char_largest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_smallest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_largest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_smallest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_largest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_float( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_float_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_float_smallest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_float_largest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_float_smallest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_float_largest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_int( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_int_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_int_smallest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_int_largest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_int_smallest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_int_largest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_long( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_long_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_long_smallest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_long_largest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_long_smallest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_long_largest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_long_double( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_long_double_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_long_double_smallest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_long_double_largest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_long_double_smallest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_long_double_largest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_short( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_short_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_short_smallest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_short_largest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_short_smallest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_short_largest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_uchar( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_uchar_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_uchar_smallest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_uchar_largest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_uchar_smallest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_uchar_largest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_uint( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_uint_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_uint_smallest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_uint_largest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_uint_smallest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_uint_largest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_ulong( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_ulong_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_ulong_smallest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_ulong_largest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_ulong_smallest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_ulong_largest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_ushort( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_ushort_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_ushort_smallest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_ushort_largest( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_ushort_smallest_index( DaoContext *_ctx, DValue *_p[], int _n );
static void dao__gsl_sort_vector_ushort_largest_index( DaoContext *_ctx, DValue *_p[], int _n );

static DaoFuncItem dao_Funcs[] =
{
  { dao__gsl_sort_char, "gsl_sort_char( data : string, stride : int, n : int )" },
  { dao__gsl_sort_char_index, "gsl_sort_char_index( p : int, data : string, stride : int, n : int )" },
  { dao__gsl_sort_char_smallest, "gsl_sort_char_smallest( dest : string, k : int, src : string, stride : int, n : int )=>int" },
  { dao__gsl_sort_char_smallest_index, "gsl_sort_char_smallest_index( p : array<int>, k : int, src : string, stride : int, n : int )=>int" },
  { dao__gsl_sort_char_largest, "gsl_sort_char_largest( dest : string, k : int, src : string, stride : int, n : int )=>int" },
  { dao__gsl_sort_char_largest_index, "gsl_sort_char_largest_index( p : array<int>, k : int, src : string, stride : int, n : int )=>int" },
  { dao__gsl_sort, "gsl_sort( data : array<double>, stride : int, n : int )" },
  { dao__gsl_sort_index, "gsl_sort_index( p : int, data : array<double>, stride : int, n : int )" },
  { dao__gsl_sort_smallest, "gsl_sort_smallest( dest : array<double>, k : int, src : array<double>, stride : int, n : int )=>int" },
  { dao__gsl_sort_smallest_index, "gsl_sort_smallest_index( p : array<int>, k : int, src : array<double>, stride : int, n : int )=>int" },
  { dao__gsl_sort_largest, "gsl_sort_largest( dest : array<double>, k : int, src : array<double>, stride : int, n : int )=>int" },
  { dao__gsl_sort_largest_index, "gsl_sort_largest_index( p : array<int>, k : int, src : array<double>, stride : int, n : int )=>int" },
  { dao__gsl_sort_float, "gsl_sort_float( data : array<float>, stride : int, n : int )" },
  { dao__gsl_sort_float_index, "gsl_sort_float_index( p : int, data : array<float>, stride : int, n : int )" },
  { dao__gsl_sort_float_smallest, "gsl_sort_float_smallest( dest : array<float>, k : int, src : array<float>, stride : int, n : int )=>int" },
  { dao__gsl_sort_float_smallest_index, "gsl_sort_float_smallest_index( p : array<int>, k : int, src : array<float>, stride : int, n : int )=>int" },
  { dao__gsl_sort_float_largest, "gsl_sort_float_largest( dest : array<float>, k : int, src : array<float>, stride : int, n : int )=>int" },
  { dao__gsl_sort_float_largest_index, "gsl_sort_float_largest_index( p : array<int>, k : int, src : array<float>, stride : int, n : int )=>int" },
  { dao__gsl_sort_int, "gsl_sort_int( data : array<int>, stride : int, n : int )" },
  { dao__gsl_sort_int_index, "gsl_sort_int_index( p : int, data : array<int>, stride : int, n : int )" },
  { dao__gsl_sort_int_smallest, "gsl_sort_int_smallest( dest : array<int>, k : int, src : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_sort_int_smallest_index, "gsl_sort_int_smallest_index( p : array<int>, k : int, src : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_sort_int_largest, "gsl_sort_int_largest( dest : array<int>, k : int, src : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_sort_int_largest_index, "gsl_sort_int_largest_index( p : array<int>, k : int, src : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_sort_long, "gsl_sort_long( data : array<int>, stride : int, n : int )" },
  { dao__gsl_sort_long_index, "gsl_sort_long_index( p : int, data : array<int>, stride : int, n : int )" },
  { dao__gsl_sort_long_smallest, "gsl_sort_long_smallest( dest : array<int>, k : int, src : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_sort_long_smallest_index, "gsl_sort_long_smallest_index( p : array<int>, k : int, src : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_sort_long_largest, "gsl_sort_long_largest( dest : array<int>, k : int, src : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_sort_long_largest_index, "gsl_sort_long_largest_index( p : array<int>, k : int, src : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_sort_long_double, "gsl_sort_long_double( data : array<double>, stride : int, n : int )" },
  { dao__gsl_sort_long_double_index, "gsl_sort_long_double_index( p : int, data : array<double>, stride : int, n : int )" },
  { dao__gsl_sort_long_double_smallest, "gsl_sort_long_double_smallest( dest : array<double>, k : int, src : array<double>, stride : int, n : int )=>int" },
  { dao__gsl_sort_long_double_smallest_index, "gsl_sort_long_double_smallest_index( p : array<int>, k : int, src : array<double>, stride : int, n : int )=>int" },
  { dao__gsl_sort_long_double_largest, "gsl_sort_long_double_largest( dest : array<double>, k : int, src : array<double>, stride : int, n : int )=>int" },
  { dao__gsl_sort_long_double_largest_index, "gsl_sort_long_double_largest_index( p : array<int>, k : int, src : array<double>, stride : int, n : int )=>int" },
  { dao__gsl_sort_short, "gsl_sort_short( data : array<int>, stride : int, n : int )" },
  { dao__gsl_sort_short_index, "gsl_sort_short_index( p : int, data : array<int>, stride : int, n : int )" },
  { dao__gsl_sort_short_smallest, "gsl_sort_short_smallest( dest : array<int>, k : int, src : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_sort_short_smallest_index, "gsl_sort_short_smallest_index( p : array<int>, k : int, src : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_sort_short_largest, "gsl_sort_short_largest( dest : array<int>, k : int, src : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_sort_short_largest_index, "gsl_sort_short_largest_index( p : array<int>, k : int, src : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_sort_uchar, "gsl_sort_uchar( data : string, stride : int, n : int )" },
  { dao__gsl_sort_uchar_index, "gsl_sort_uchar_index( p : int, data : string, stride : int, n : int )" },
  { dao__gsl_sort_uchar_smallest, "gsl_sort_uchar_smallest( dest : string, k : int, src : string, stride : int, n : int )=>int" },
  { dao__gsl_sort_uchar_smallest_index, "gsl_sort_uchar_smallest_index( p : array<int>, k : int, src : string, stride : int, n : int )=>int" },
  { dao__gsl_sort_uchar_largest, "gsl_sort_uchar_largest( dest : string, k : int, src : string, stride : int, n : int )=>int" },
  { dao__gsl_sort_uchar_largest_index, "gsl_sort_uchar_largest_index( p : array<int>, k : int, src : string, stride : int, n : int )=>int" },
  { dao__gsl_sort_uint, "gsl_sort_uint( data : array<int>, stride : int, n : int )" },
  { dao__gsl_sort_uint_index, "gsl_sort_uint_index( p : int, data : array<int>, stride : int, n : int )" },
  { dao__gsl_sort_uint_smallest, "gsl_sort_uint_smallest( dest : array<int>, k : int, src : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_sort_uint_smallest_index, "gsl_sort_uint_smallest_index( p : array<int>, k : int, src : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_sort_uint_largest, "gsl_sort_uint_largest( dest : array<int>, k : int, src : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_sort_uint_largest_index, "gsl_sort_uint_largest_index( p : array<int>, k : int, src : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_sort_ulong, "gsl_sort_ulong( data : array<int>, stride : int, n : int )" },
  { dao__gsl_sort_ulong_index, "gsl_sort_ulong_index( p : int, data : array<int>, stride : int, n : int )" },
  { dao__gsl_sort_ulong_smallest, "gsl_sort_ulong_smallest( dest : array<int>, k : int, src : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_sort_ulong_smallest_index, "gsl_sort_ulong_smallest_index( p : array<int>, k : int, src : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_sort_ulong_largest, "gsl_sort_ulong_largest( dest : array<int>, k : int, src : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_sort_ulong_largest_index, "gsl_sort_ulong_largest_index( p : array<int>, k : int, src : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_sort_ushort, "gsl_sort_ushort( data : array<int>, stride : int, n : int )" },
  { dao__gsl_sort_ushort_index, "gsl_sort_ushort_index( p : int, data : array<int>, stride : int, n : int )" },
  { dao__gsl_sort_ushort_smallest, "gsl_sort_ushort_smallest( dest : array<int>, k : int, src : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_sort_ushort_smallest_index, "gsl_sort_ushort_smallest_index( p : array<int>, k : int, src : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_sort_ushort_largest, "gsl_sort_ushort_largest( dest : array<int>, k : int, src : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_sort_ushort_largest_index, "gsl_sort_ushort_largest_index( p : array<int>, k : int, src : array<int>, stride : int, n : int )=>int" },
  { dao__gsl_sort_vector_char, "gsl_sort_vector_char( v : gsl_vector_char )" },
  { dao__gsl_sort_vector_char_index, "gsl_sort_vector_char_index( p : gsl_permutation, v : gsl_vector_char )=>int" },
  { dao__gsl_sort_vector_char_smallest, "gsl_sort_vector_char_smallest( dest : string, k : int, v : gsl_vector_char )=>int" },
  { dao__gsl_sort_vector_char_largest, "gsl_sort_vector_char_largest( dest : string, k : int, v : gsl_vector_char )=>int" },
  { dao__gsl_sort_vector_char_smallest_index, "gsl_sort_vector_char_smallest_index( p : array<int>, k : int, v : gsl_vector_char )=>int" },
  { dao__gsl_sort_vector_char_largest_index, "gsl_sort_vector_char_largest_index( p : array<int>, k : int, v : gsl_vector_char )=>int" },
  { dao__gsl_sort_vector, "gsl_sort_vector( v : gsl_vector )" },
  { dao__gsl_sort_vector_index, "gsl_sort_vector_index( p : gsl_permutation, v : gsl_vector )=>int" },
  { dao__gsl_sort_vector_smallest, "gsl_sort_vector_smallest( dest : array<double>, k : int, v : gsl_vector )=>int" },
  { dao__gsl_sort_vector_largest, "gsl_sort_vector_largest( dest : array<double>, k : int, v : gsl_vector )=>int" },
  { dao__gsl_sort_vector_smallest_index, "gsl_sort_vector_smallest_index( p : array<int>, k : int, v : gsl_vector )=>int" },
  { dao__gsl_sort_vector_largest_index, "gsl_sort_vector_largest_index( p : array<int>, k : int, v : gsl_vector )=>int" },
  { dao__gsl_sort_vector_float, "gsl_sort_vector_float( v : gsl_vector_float )" },
  { dao__gsl_sort_vector_float_index, "gsl_sort_vector_float_index( p : gsl_permutation, v : gsl_vector_float )=>int" },
  { dao__gsl_sort_vector_float_smallest, "gsl_sort_vector_float_smallest( dest : array<float>, k : int, v : gsl_vector_float )=>int" },
  { dao__gsl_sort_vector_float_largest, "gsl_sort_vector_float_largest( dest : array<float>, k : int, v : gsl_vector_float )=>int" },
  { dao__gsl_sort_vector_float_smallest_index, "gsl_sort_vector_float_smallest_index( p : array<int>, k : int, v : gsl_vector_float )=>int" },
  { dao__gsl_sort_vector_float_largest_index, "gsl_sort_vector_float_largest_index( p : array<int>, k : int, v : gsl_vector_float )=>int" },
  { dao__gsl_sort_vector_int, "gsl_sort_vector_int( v : gsl_vector_int )" },
  { dao__gsl_sort_vector_int_index, "gsl_sort_vector_int_index( p : gsl_permutation, v : gsl_vector_int )=>int" },
  { dao__gsl_sort_vector_int_smallest, "gsl_sort_vector_int_smallest( dest : array<int>, k : int, v : gsl_vector_int )=>int" },
  { dao__gsl_sort_vector_int_largest, "gsl_sort_vector_int_largest( dest : array<int>, k : int, v : gsl_vector_int )=>int" },
  { dao__gsl_sort_vector_int_smallest_index, "gsl_sort_vector_int_smallest_index( p : array<int>, k : int, v : gsl_vector_int )=>int" },
  { dao__gsl_sort_vector_int_largest_index, "gsl_sort_vector_int_largest_index( p : array<int>, k : int, v : gsl_vector_int )=>int" },
  { dao__gsl_sort_vector_long, "gsl_sort_vector_long( v : gsl_vector_long )" },
  { dao__gsl_sort_vector_long_index, "gsl_sort_vector_long_index( p : gsl_permutation, v : gsl_vector_long )=>int" },
  { dao__gsl_sort_vector_long_smallest, "gsl_sort_vector_long_smallest( dest : array<int>, k : int, v : gsl_vector_long )=>int" },
  { dao__gsl_sort_vector_long_largest, "gsl_sort_vector_long_largest( dest : array<int>, k : int, v : gsl_vector_long )=>int" },
  { dao__gsl_sort_vector_long_smallest_index, "gsl_sort_vector_long_smallest_index( p : array<int>, k : int, v : gsl_vector_long )=>int" },
  { dao__gsl_sort_vector_long_largest_index, "gsl_sort_vector_long_largest_index( p : array<int>, k : int, v : gsl_vector_long )=>int" },
  { dao__gsl_sort_vector_long_double, "gsl_sort_vector_long_double( v : gsl_vector_long_double )" },
  { dao__gsl_sort_vector_long_double_index, "gsl_sort_vector_long_double_index( p : gsl_permutation, v : gsl_vector_long_double )=>int" },
  { dao__gsl_sort_vector_long_double_smallest, "gsl_sort_vector_long_double_smallest( dest : array<double>, k : int, v : gsl_vector_long_double )=>int" },
  { dao__gsl_sort_vector_long_double_largest, "gsl_sort_vector_long_double_largest( dest : array<double>, k : int, v : gsl_vector_long_double )=>int" },
  { dao__gsl_sort_vector_long_double_smallest_index, "gsl_sort_vector_long_double_smallest_index( p : array<int>, k : int, v : gsl_vector_long_double )=>int" },
  { dao__gsl_sort_vector_long_double_largest_index, "gsl_sort_vector_long_double_largest_index( p : array<int>, k : int, v : gsl_vector_long_double )=>int" },
  { dao__gsl_sort_vector_short, "gsl_sort_vector_short( v : gsl_vector_short )" },
  { dao__gsl_sort_vector_short_index, "gsl_sort_vector_short_index( p : gsl_permutation, v : gsl_vector_short )=>int" },
  { dao__gsl_sort_vector_short_smallest, "gsl_sort_vector_short_smallest( dest : array<int>, k : int, v : gsl_vector_short )=>int" },
  { dao__gsl_sort_vector_short_largest, "gsl_sort_vector_short_largest( dest : array<int>, k : int, v : gsl_vector_short )=>int" },
  { dao__gsl_sort_vector_short_smallest_index, "gsl_sort_vector_short_smallest_index( p : array<int>, k : int, v : gsl_vector_short )=>int" },
  { dao__gsl_sort_vector_short_largest_index, "gsl_sort_vector_short_largest_index( p : array<int>, k : int, v : gsl_vector_short )=>int" },
  { dao__gsl_sort_vector_uchar, "gsl_sort_vector_uchar( v : gsl_vector_uchar )" },
  { dao__gsl_sort_vector_uchar_index, "gsl_sort_vector_uchar_index( p : gsl_permutation, v : gsl_vector_uchar )=>int" },
  { dao__gsl_sort_vector_uchar_smallest, "gsl_sort_vector_uchar_smallest( dest : string, k : int, v : gsl_vector_uchar )=>int" },
  { dao__gsl_sort_vector_uchar_largest, "gsl_sort_vector_uchar_largest( dest : string, k : int, v : gsl_vector_uchar )=>int" },
  { dao__gsl_sort_vector_uchar_smallest_index, "gsl_sort_vector_uchar_smallest_index( p : array<int>, k : int, v : gsl_vector_uchar )=>int" },
  { dao__gsl_sort_vector_uchar_largest_index, "gsl_sort_vector_uchar_largest_index( p : array<int>, k : int, v : gsl_vector_uchar )=>int" },
  { dao__gsl_sort_vector_uint, "gsl_sort_vector_uint( v : gsl_vector_uint )" },
  { dao__gsl_sort_vector_uint_index, "gsl_sort_vector_uint_index( p : gsl_permutation, v : gsl_vector_uint )=>int" },
  { dao__gsl_sort_vector_uint_smallest, "gsl_sort_vector_uint_smallest( dest : array<int>, k : int, v : gsl_vector_uint )=>int" },
  { dao__gsl_sort_vector_uint_largest, "gsl_sort_vector_uint_largest( dest : array<int>, k : int, v : gsl_vector_uint )=>int" },
  { dao__gsl_sort_vector_uint_smallest_index, "gsl_sort_vector_uint_smallest_index( p : array<int>, k : int, v : gsl_vector_uint )=>int" },
  { dao__gsl_sort_vector_uint_largest_index, "gsl_sort_vector_uint_largest_index( p : array<int>, k : int, v : gsl_vector_uint )=>int" },
  { dao__gsl_sort_vector_ulong, "gsl_sort_vector_ulong( v : gsl_vector_ulong )" },
  { dao__gsl_sort_vector_ulong_index, "gsl_sort_vector_ulong_index( p : gsl_permutation, v : gsl_vector_ulong )=>int" },
  { dao__gsl_sort_vector_ulong_smallest, "gsl_sort_vector_ulong_smallest( dest : array<int>, k : int, v : gsl_vector_ulong )=>int" },
  { dao__gsl_sort_vector_ulong_largest, "gsl_sort_vector_ulong_largest( dest : array<int>, k : int, v : gsl_vector_ulong )=>int" },
  { dao__gsl_sort_vector_ulong_smallest_index, "gsl_sort_vector_ulong_smallest_index( p : array<int>, k : int, v : gsl_vector_ulong )=>int" },
  { dao__gsl_sort_vector_ulong_largest_index, "gsl_sort_vector_ulong_largest_index( p : array<int>, k : int, v : gsl_vector_ulong )=>int" },
  { dao__gsl_sort_vector_ushort, "gsl_sort_vector_ushort( v : gsl_vector_ushort )" },
  { dao__gsl_sort_vector_ushort_index, "gsl_sort_vector_ushort_index( p : gsl_permutation, v : gsl_vector_ushort )=>int" },
  { dao__gsl_sort_vector_ushort_smallest, "gsl_sort_vector_ushort_smallest( dest : array<int>, k : int, v : gsl_vector_ushort )=>int" },
  { dao__gsl_sort_vector_ushort_largest, "gsl_sort_vector_ushort_largest( dest : array<int>, k : int, v : gsl_vector_ushort )=>int" },
  { dao__gsl_sort_vector_ushort_smallest_index, "gsl_sort_vector_ushort_smallest_index( p : array<int>, k : int, v : gsl_vector_ushort )=>int" },
  { dao__gsl_sort_vector_ushort_largest_index, "gsl_sort_vector_ushort_largest_index( p : array<int>, k : int, v : gsl_vector_ushort )=>int" },
  { NULL, NULL }
};
/* gsl_sort_char.h */
static void dao__gsl_sort_char( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* data= (char*) DString_GetMBS( _p[0]->v.s );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  gsl_sort_char( data, stride, n );
  DString_SetMBS( _p[0]->v.s, (char*) data );
}
/* gsl_sort_char.h */
static void dao__gsl_sort_char_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t p= (size_t) _p[0]->v.i;
  char* data= (char*) DString_GetMBS( _p[1]->v.s );
  size_t stride= (size_t) _p[2]->v.i;
  size_t n= (size_t) _p[3]->v.i;

  gsl_sort_char_index( & p, data, stride, n );
  _p[0]->v.i = (int) p;
}
/* gsl_sort_char.h */
static void dao__gsl_sort_char_smallest( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* dest= (char*) DString_GetMBS( _p[0]->v.s );
  size_t k= (size_t) _p[1]->v.i;
  char* src= (char*) DString_GetMBS( _p[2]->v.s );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_char_smallest = gsl_sort_char_smallest( dest, k, src, stride, n );
  DString_SetMBS( _p[0]->v.s, (char*) dest );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_char_smallest );
}
/* gsl_sort_char.h */
static void dao__gsl_sort_char_smallest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  char* src= (char*) DString_GetMBS( _p[2]->v.s );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_char_smallest_index = gsl_sort_char_smallest_index( p, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_char_smallest_index );
}
/* gsl_sort_char.h */
static void dao__gsl_sort_char_largest( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* dest= (char*) DString_GetMBS( _p[0]->v.s );
  size_t k= (size_t) _p[1]->v.i;
  char* src= (char*) DString_GetMBS( _p[2]->v.s );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_char_largest = gsl_sort_char_largest( dest, k, src, stride, n );
  DString_SetMBS( _p[0]->v.s, (char*) dest );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_char_largest );
}
/* gsl_sort_char.h */
static void dao__gsl_sort_char_largest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  char* src= (char*) DString_GetMBS( _p[2]->v.s );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_char_largest_index = gsl_sort_char_largest_index( p, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_char_largest_index );
}
/* gsl_sort_double.h */
static void dao__gsl_sort( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* data= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  gsl_sort( data, stride, n );
}
/* gsl_sort_double.h */
static void dao__gsl_sort_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t p= (size_t) _p[0]->v.i;
  double* data= (double*) DaoArray_ToDouble( _p[1]->v.array );
  size_t stride= (size_t) _p[2]->v.i;
  size_t n= (size_t) _p[3]->v.i;

  gsl_sort_index( & p, data, stride, n );
  _p[0]->v.i = (int) p;
}
/* gsl_sort_double.h */
static void dao__gsl_sort_smallest( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* dest= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  double* src= (double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_smallest = gsl_sort_smallest( dest, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_smallest );
}
/* gsl_sort_double.h */
static void dao__gsl_sort_smallest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  double* src= (double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_smallest_index = gsl_sort_smallest_index( p, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_smallest_index );
}
/* gsl_sort_double.h */
static void dao__gsl_sort_largest( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* dest= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  double* src= (double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_largest = gsl_sort_largest( dest, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_largest );
}
/* gsl_sort_double.h */
static void dao__gsl_sort_largest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  double* src= (double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_largest_index = gsl_sort_largest_index( p, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_largest_index );
}
/* gsl_sort_float.h */
static void dao__gsl_sort_float( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* data= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  gsl_sort_float( data, stride, n );
}
/* gsl_sort_float.h */
static void dao__gsl_sort_float_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t p= (size_t) _p[0]->v.i;
  float* data= (float*) DaoArray_ToFloat( _p[1]->v.array );
  size_t stride= (size_t) _p[2]->v.i;
  size_t n= (size_t) _p[3]->v.i;

  gsl_sort_float_index( & p, data, stride, n );
  _p[0]->v.i = (int) p;
}
/* gsl_sort_float.h */
static void dao__gsl_sort_float_smallest( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* dest= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  float* src= (float*) DaoArray_ToFloat( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_float_smallest = gsl_sort_float_smallest( dest, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_float_smallest );
}
/* gsl_sort_float.h */
static void dao__gsl_sort_float_smallest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  float* src= (float*) DaoArray_ToFloat( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_float_smallest_index = gsl_sort_float_smallest_index( p, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_float_smallest_index );
}
/* gsl_sort_float.h */
static void dao__gsl_sort_float_largest( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* dest= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  float* src= (float*) DaoArray_ToFloat( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_float_largest = gsl_sort_float_largest( dest, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_float_largest );
}
/* gsl_sort_float.h */
static void dao__gsl_sort_float_largest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  float* src= (float*) DaoArray_ToFloat( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_float_largest_index = gsl_sort_float_largest_index( p, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_float_largest_index );
}
/* gsl_sort_int.h */
static void dao__gsl_sort_int( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* data= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  gsl_sort_int( data, stride, n );
}
/* gsl_sort_int.h */
static void dao__gsl_sort_int_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t p= (size_t) _p[0]->v.i;
  int* data= (int*) DaoArray_ToInt( _p[1]->v.array );
  size_t stride= (size_t) _p[2]->v.i;
  size_t n= (size_t) _p[3]->v.i;

  gsl_sort_int_index( & p, data, stride, n );
  _p[0]->v.i = (int) p;
}
/* gsl_sort_int.h */
static void dao__gsl_sort_int_smallest( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* dest= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  int* src= (int*) DaoArray_ToInt( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_int_smallest = gsl_sort_int_smallest( dest, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_int_smallest );
}
/* gsl_sort_int.h */
static void dao__gsl_sort_int_smallest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  int* src= (int*) DaoArray_ToInt( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_int_smallest_index = gsl_sort_int_smallest_index( p, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_int_smallest_index );
}
/* gsl_sort_int.h */
static void dao__gsl_sort_int_largest( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* dest= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  int* src= (int*) DaoArray_ToInt( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_int_largest = gsl_sort_int_largest( dest, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_int_largest );
}
/* gsl_sort_int.h */
static void dao__gsl_sort_int_largest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  int* src= (int*) DaoArray_ToInt( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_int_largest_index = gsl_sort_int_largest_index( p, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_int_largest_index );
}
/* gsl_sort_long.h */
static void dao__gsl_sort_long( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* data= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  gsl_sort_long( data, stride, n );
}
/* gsl_sort_long.h */
static void dao__gsl_sort_long_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t p= (size_t) _p[0]->v.i;
  long* data= (long*) DaoArray_ToInt( _p[1]->v.array );
  size_t stride= (size_t) _p[2]->v.i;
  size_t n= (size_t) _p[3]->v.i;

  gsl_sort_long_index( & p, data, stride, n );
  _p[0]->v.i = (int) p;
}
/* gsl_sort_long.h */
static void dao__gsl_sort_long_smallest( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* dest= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  long* src= (long*) DaoArray_ToInt( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_long_smallest = gsl_sort_long_smallest( dest, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_long_smallest );
}
/* gsl_sort_long.h */
static void dao__gsl_sort_long_smallest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  long* src= (long*) DaoArray_ToInt( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_long_smallest_index = gsl_sort_long_smallest_index( p, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_long_smallest_index );
}
/* gsl_sort_long.h */
static void dao__gsl_sort_long_largest( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* dest= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  long* src= (long*) DaoArray_ToInt( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_long_largest = gsl_sort_long_largest( dest, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_long_largest );
}
/* gsl_sort_long.h */
static void dao__gsl_sort_long_largest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  long* src= (long*) DaoArray_ToInt( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_long_largest_index = gsl_sort_long_largest_index( p, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_long_largest_index );
}
/* gsl_sort_long_double.h */
static void dao__gsl_sort_long_double( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* data= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  gsl_sort_long_double( data, stride, n );
}
/* gsl_sort_long_double.h */
static void dao__gsl_sort_long_double_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t p= (size_t) _p[0]->v.i;
  long double* data= (long double*) DaoArray_ToDouble( _p[1]->v.array );
  size_t stride= (size_t) _p[2]->v.i;
  size_t n= (size_t) _p[3]->v.i;

  gsl_sort_long_double_index( & p, data, stride, n );
  _p[0]->v.i = (int) p;
}
/* gsl_sort_long_double.h */
static void dao__gsl_sort_long_double_smallest( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* dest= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  long double* src= (long double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_long_double_smallest = gsl_sort_long_double_smallest( dest, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_long_double_smallest );
}
/* gsl_sort_long_double.h */
static void dao__gsl_sort_long_double_smallest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  long double* src= (long double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_long_double_smallest_index = gsl_sort_long_double_smallest_index( p, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_long_double_smallest_index );
}
/* gsl_sort_long_double.h */
static void dao__gsl_sort_long_double_largest( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* dest= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  long double* src= (long double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_long_double_largest = gsl_sort_long_double_largest( dest, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_long_double_largest );
}
/* gsl_sort_long_double.h */
static void dao__gsl_sort_long_double_largest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  long double* src= (long double*) DaoArray_ToDouble( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_long_double_largest_index = gsl_sort_long_double_largest_index( p, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_long_double_largest_index );
}
/* gsl_sort_short.h */
static void dao__gsl_sort_short( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* data= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  gsl_sort_short( data, stride, n );
}
/* gsl_sort_short.h */
static void dao__gsl_sort_short_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t p= (size_t) _p[0]->v.i;
  short* data= (short*) DaoArray_ToShort( _p[1]->v.array );
  size_t stride= (size_t) _p[2]->v.i;
  size_t n= (size_t) _p[3]->v.i;

  gsl_sort_short_index( & p, data, stride, n );
  _p[0]->v.i = (int) p;
}
/* gsl_sort_short.h */
static void dao__gsl_sort_short_smallest( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* dest= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  short* src= (short*) DaoArray_ToShort( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_short_smallest = gsl_sort_short_smallest( dest, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_short_smallest );
}
/* gsl_sort_short.h */
static void dao__gsl_sort_short_smallest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  short* src= (short*) DaoArray_ToShort( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_short_smallest_index = gsl_sort_short_smallest_index( p, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_short_smallest_index );
}
/* gsl_sort_short.h */
static void dao__gsl_sort_short_largest( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* dest= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  short* src= (short*) DaoArray_ToShort( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_short_largest = gsl_sort_short_largest( dest, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_short_largest );
}
/* gsl_sort_short.h */
static void dao__gsl_sort_short_largest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  short* src= (short*) DaoArray_ToShort( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_short_largest_index = gsl_sort_short_largest_index( p, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_short_largest_index );
}
/* gsl_sort_uchar.h */
static void dao__gsl_sort_uchar( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* data= (unsigned char*) DString_GetMBS( _p[0]->v.s );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  gsl_sort_uchar( data, stride, n );
  DString_SetMBS( _p[0]->v.s, (char*) data );
}
/* gsl_sort_uchar.h */
static void dao__gsl_sort_uchar_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t p= (size_t) _p[0]->v.i;
  unsigned char* data= (unsigned char*) DString_GetMBS( _p[1]->v.s );
  size_t stride= (size_t) _p[2]->v.i;
  size_t n= (size_t) _p[3]->v.i;

  gsl_sort_uchar_index( & p, data, stride, n );
  _p[0]->v.i = (int) p;
}
/* gsl_sort_uchar.h */
static void dao__gsl_sort_uchar_smallest( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* dest= (unsigned char*) DString_GetMBS( _p[0]->v.s );
  size_t k= (size_t) _p[1]->v.i;
  unsigned char* src= (unsigned char*) DString_GetMBS( _p[2]->v.s );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_uchar_smallest = gsl_sort_uchar_smallest( dest, k, src, stride, n );
  DString_SetMBS( _p[0]->v.s, (char*) dest );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_uchar_smallest );
}
/* gsl_sort_uchar.h */
static void dao__gsl_sort_uchar_smallest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  unsigned char* src= (unsigned char*) DString_GetMBS( _p[2]->v.s );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_uchar_smallest_index = gsl_sort_uchar_smallest_index( p, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_uchar_smallest_index );
}
/* gsl_sort_uchar.h */
static void dao__gsl_sort_uchar_largest( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* dest= (unsigned char*) DString_GetMBS( _p[0]->v.s );
  size_t k= (size_t) _p[1]->v.i;
  unsigned char* src= (unsigned char*) DString_GetMBS( _p[2]->v.s );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_uchar_largest = gsl_sort_uchar_largest( dest, k, src, stride, n );
  DString_SetMBS( _p[0]->v.s, (char*) dest );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_uchar_largest );
}
/* gsl_sort_uchar.h */
static void dao__gsl_sort_uchar_largest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  unsigned char* src= (unsigned char*) DString_GetMBS( _p[2]->v.s );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_uchar_largest_index = gsl_sort_uchar_largest_index( p, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_uchar_largest_index );
}
/* gsl_sort_uint.h */
static void dao__gsl_sort_uint( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* data= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  gsl_sort_uint( data, stride, n );
}
/* gsl_sort_uint.h */
static void dao__gsl_sort_uint_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t p= (size_t) _p[0]->v.i;
  unsigned int* data= (unsigned int*) DaoArray_ToUInt( _p[1]->v.array );
  size_t stride= (size_t) _p[2]->v.i;
  size_t n= (size_t) _p[3]->v.i;

  gsl_sort_uint_index( & p, data, stride, n );
  _p[0]->v.i = (int) p;
}
/* gsl_sort_uint.h */
static void dao__gsl_sort_uint_smallest( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* dest= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  unsigned int* src= (unsigned int*) DaoArray_ToUInt( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_uint_smallest = gsl_sort_uint_smallest( dest, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_uint_smallest );
}
/* gsl_sort_uint.h */
static void dao__gsl_sort_uint_smallest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  unsigned int* src= (unsigned int*) DaoArray_ToUInt( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_uint_smallest_index = gsl_sort_uint_smallest_index( p, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_uint_smallest_index );
}
/* gsl_sort_uint.h */
static void dao__gsl_sort_uint_largest( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* dest= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  unsigned int* src= (unsigned int*) DaoArray_ToUInt( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_uint_largest = gsl_sort_uint_largest( dest, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_uint_largest );
}
/* gsl_sort_uint.h */
static void dao__gsl_sort_uint_largest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  unsigned int* src= (unsigned int*) DaoArray_ToUInt( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_uint_largest_index = gsl_sort_uint_largest_index( p, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_uint_largest_index );
}
/* gsl_sort_ulong.h */
static void dao__gsl_sort_ulong( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* data= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  gsl_sort_ulong( data, stride, n );
}
/* gsl_sort_ulong.h */
static void dao__gsl_sort_ulong_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t p= (size_t) _p[0]->v.i;
  unsigned long* data= (unsigned long*) DaoArray_ToUInt( _p[1]->v.array );
  size_t stride= (size_t) _p[2]->v.i;
  size_t n= (size_t) _p[3]->v.i;

  gsl_sort_ulong_index( & p, data, stride, n );
  _p[0]->v.i = (int) p;
}
/* gsl_sort_ulong.h */
static void dao__gsl_sort_ulong_smallest( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* dest= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  unsigned long* src= (unsigned long*) DaoArray_ToUInt( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_ulong_smallest = gsl_sort_ulong_smallest( dest, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_ulong_smallest );
}
/* gsl_sort_ulong.h */
static void dao__gsl_sort_ulong_smallest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  unsigned long* src= (unsigned long*) DaoArray_ToUInt( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_ulong_smallest_index = gsl_sort_ulong_smallest_index( p, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_ulong_smallest_index );
}
/* gsl_sort_ulong.h */
static void dao__gsl_sort_ulong_largest( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* dest= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  unsigned long* src= (unsigned long*) DaoArray_ToUInt( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_ulong_largest = gsl_sort_ulong_largest( dest, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_ulong_largest );
}
/* gsl_sort_ulong.h */
static void dao__gsl_sort_ulong_largest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  unsigned long* src= (unsigned long*) DaoArray_ToUInt( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_ulong_largest_index = gsl_sort_ulong_largest_index( p, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_ulong_largest_index );
}
/* gsl_sort_ushort.h */
static void dao__gsl_sort_ushort( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* data= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t stride= (size_t) _p[1]->v.i;
  size_t n= (size_t) _p[2]->v.i;

  gsl_sort_ushort( data, stride, n );
}
/* gsl_sort_ushort.h */
static void dao__gsl_sort_ushort_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t p= (size_t) _p[0]->v.i;
  unsigned short* data= (unsigned short*) DaoArray_ToUShort( _p[1]->v.array );
  size_t stride= (size_t) _p[2]->v.i;
  size_t n= (size_t) _p[3]->v.i;

  gsl_sort_ushort_index( & p, data, stride, n );
  _p[0]->v.i = (int) p;
}
/* gsl_sort_ushort.h */
static void dao__gsl_sort_ushort_smallest( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* dest= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  unsigned short* src= (unsigned short*) DaoArray_ToUShort( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_ushort_smallest = gsl_sort_ushort_smallest( dest, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_ushort_smallest );
}
/* gsl_sort_ushort.h */
static void dao__gsl_sort_ushort_smallest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  unsigned short* src= (unsigned short*) DaoArray_ToUShort( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_ushort_smallest_index = gsl_sort_ushort_smallest_index( p, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_ushort_smallest_index );
}
/* gsl_sort_ushort.h */
static void dao__gsl_sort_ushort_largest( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* dest= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  unsigned short* src= (unsigned short*) DaoArray_ToUShort( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_ushort_largest = gsl_sort_ushort_largest( dest, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_ushort_largest );
}
/* gsl_sort_ushort.h */
static void dao__gsl_sort_ushort_largest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  unsigned short* src= (unsigned short*) DaoArray_ToUShort( _p[2]->v.array );
  size_t stride= (size_t) _p[3]->v.i;
  size_t n= (size_t) _p[4]->v.i;

  int _gsl_sort_ushort_largest_index = gsl_sort_ushort_largest_index( p, k, src, stride, n );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_ushort_largest_index );
}
/* gsl_sort_vector_char.h */
static void dao__gsl_sort_vector_char( DaoContext *_ctx, DValue *_p[], int _n )
{
  gsl_vector_char* v= (gsl_vector_char*) DaoCData_CastData( _p[0]->v.cdata, dao_gsl_vector_char_Typer );

  gsl_sort_vector_char( v );
}
/* gsl_sort_vector_char.h */
static void dao__gsl_sort_vector_char_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  gsl_permutation* p= (gsl_permutation*) DaoCData_CastData( _p[0]->v.cdata, dao_gsl_permutation_Typer );
  gsl_vector_char* v= (gsl_vector_char*) DaoCData_CastData( _p[1]->v.cdata, dao_gsl_vector_char_Typer );

  int _gsl_sort_vector_char_index = gsl_sort_vector_char_index( p, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_char_index );
}
/* gsl_sort_vector_char.h */
static void dao__gsl_sort_vector_char_smallest( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* dest= (char*) DString_GetMBS( _p[0]->v.s );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_char* v= (gsl_vector_char*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_char_Typer );

  int _gsl_sort_vector_char_smallest = gsl_sort_vector_char_smallest( dest, k, v );
  DString_SetMBS( _p[0]->v.s, (char*) dest );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_char_smallest );
}
/* gsl_sort_vector_char.h */
static void dao__gsl_sort_vector_char_largest( DaoContext *_ctx, DValue *_p[], int _n )
{
  char* dest= (char*) DString_GetMBS( _p[0]->v.s );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_char* v= (gsl_vector_char*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_char_Typer );

  int _gsl_sort_vector_char_largest = gsl_sort_vector_char_largest( dest, k, v );
  DString_SetMBS( _p[0]->v.s, (char*) dest );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_char_largest );
}
/* gsl_sort_vector_char.h */
static void dao__gsl_sort_vector_char_smallest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_char* v= (gsl_vector_char*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_char_Typer );

  int _gsl_sort_vector_char_smallest_index = gsl_sort_vector_char_smallest_index( p, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_char_smallest_index );
}
/* gsl_sort_vector_char.h */
static void dao__gsl_sort_vector_char_largest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_char* v= (gsl_vector_char*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_char_Typer );

  int _gsl_sort_vector_char_largest_index = gsl_sort_vector_char_largest_index( p, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_char_largest_index );
}
/* gsl_sort_vector_double.h */
static void dao__gsl_sort_vector( DaoContext *_ctx, DValue *_p[], int _n )
{
  gsl_vector* v= (gsl_vector*) DaoCData_CastData( _p[0]->v.cdata, dao_gsl_vector_Typer );

  gsl_sort_vector( v );
}
/* gsl_sort_vector_double.h */
static void dao__gsl_sort_vector_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  gsl_permutation* p= (gsl_permutation*) DaoCData_CastData( _p[0]->v.cdata, dao_gsl_permutation_Typer );
  gsl_vector* v= (gsl_vector*) DaoCData_CastData( _p[1]->v.cdata, dao_gsl_vector_Typer );

  int _gsl_sort_vector_index = gsl_sort_vector_index( p, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_index );
}
/* gsl_sort_vector_double.h */
static void dao__gsl_sort_vector_smallest( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* dest= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector* v= (gsl_vector*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_Typer );

  int _gsl_sort_vector_smallest = gsl_sort_vector_smallest( dest, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_smallest );
}
/* gsl_sort_vector_double.h */
static void dao__gsl_sort_vector_largest( DaoContext *_ctx, DValue *_p[], int _n )
{
  double* dest= (double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector* v= (gsl_vector*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_Typer );

  int _gsl_sort_vector_largest = gsl_sort_vector_largest( dest, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_largest );
}
/* gsl_sort_vector_double.h */
static void dao__gsl_sort_vector_smallest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector* v= (gsl_vector*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_Typer );

  int _gsl_sort_vector_smallest_index = gsl_sort_vector_smallest_index( p, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_smallest_index );
}
/* gsl_sort_vector_double.h */
static void dao__gsl_sort_vector_largest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector* v= (gsl_vector*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_Typer );

  int _gsl_sort_vector_largest_index = gsl_sort_vector_largest_index( p, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_largest_index );
}
/* gsl_sort_vector_float.h */
static void dao__gsl_sort_vector_float( DaoContext *_ctx, DValue *_p[], int _n )
{
  gsl_vector_float* v= (gsl_vector_float*) DaoCData_CastData( _p[0]->v.cdata, dao_gsl_vector_float_Typer );

  gsl_sort_vector_float( v );
}
/* gsl_sort_vector_float.h */
static void dao__gsl_sort_vector_float_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  gsl_permutation* p= (gsl_permutation*) DaoCData_CastData( _p[0]->v.cdata, dao_gsl_permutation_Typer );
  gsl_vector_float* v= (gsl_vector_float*) DaoCData_CastData( _p[1]->v.cdata, dao_gsl_vector_float_Typer );

  int _gsl_sort_vector_float_index = gsl_sort_vector_float_index( p, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_float_index );
}
/* gsl_sort_vector_float.h */
static void dao__gsl_sort_vector_float_smallest( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* dest= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_float* v= (gsl_vector_float*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_float_Typer );

  int _gsl_sort_vector_float_smallest = gsl_sort_vector_float_smallest( dest, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_float_smallest );
}
/* gsl_sort_vector_float.h */
static void dao__gsl_sort_vector_float_largest( DaoContext *_ctx, DValue *_p[], int _n )
{
  float* dest= (float*) DaoArray_ToFloat( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_float* v= (gsl_vector_float*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_float_Typer );

  int _gsl_sort_vector_float_largest = gsl_sort_vector_float_largest( dest, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_float_largest );
}
/* gsl_sort_vector_float.h */
static void dao__gsl_sort_vector_float_smallest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_float* v= (gsl_vector_float*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_float_Typer );

  int _gsl_sort_vector_float_smallest_index = gsl_sort_vector_float_smallest_index( p, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_float_smallest_index );
}
/* gsl_sort_vector_float.h */
static void dao__gsl_sort_vector_float_largest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_float* v= (gsl_vector_float*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_float_Typer );

  int _gsl_sort_vector_float_largest_index = gsl_sort_vector_float_largest_index( p, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_float_largest_index );
}
/* gsl_sort_vector_int.h */
static void dao__gsl_sort_vector_int( DaoContext *_ctx, DValue *_p[], int _n )
{
  gsl_vector_int* v= (gsl_vector_int*) DaoCData_CastData( _p[0]->v.cdata, dao_gsl_vector_int_Typer );

  gsl_sort_vector_int( v );
}
/* gsl_sort_vector_int.h */
static void dao__gsl_sort_vector_int_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  gsl_permutation* p= (gsl_permutation*) DaoCData_CastData( _p[0]->v.cdata, dao_gsl_permutation_Typer );
  gsl_vector_int* v= (gsl_vector_int*) DaoCData_CastData( _p[1]->v.cdata, dao_gsl_vector_int_Typer );

  int _gsl_sort_vector_int_index = gsl_sort_vector_int_index( p, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_int_index );
}
/* gsl_sort_vector_int.h */
static void dao__gsl_sort_vector_int_smallest( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* dest= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_int* v= (gsl_vector_int*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_int_Typer );

  int _gsl_sort_vector_int_smallest = gsl_sort_vector_int_smallest( dest, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_int_smallest );
}
/* gsl_sort_vector_int.h */
static void dao__gsl_sort_vector_int_largest( DaoContext *_ctx, DValue *_p[], int _n )
{
  int* dest= (int*) DaoArray_ToInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_int* v= (gsl_vector_int*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_int_Typer );

  int _gsl_sort_vector_int_largest = gsl_sort_vector_int_largest( dest, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_int_largest );
}
/* gsl_sort_vector_int.h */
static void dao__gsl_sort_vector_int_smallest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_int* v= (gsl_vector_int*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_int_Typer );

  int _gsl_sort_vector_int_smallest_index = gsl_sort_vector_int_smallest_index( p, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_int_smallest_index );
}
/* gsl_sort_vector_int.h */
static void dao__gsl_sort_vector_int_largest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_int* v= (gsl_vector_int*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_int_Typer );

  int _gsl_sort_vector_int_largest_index = gsl_sort_vector_int_largest_index( p, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_int_largest_index );
}
/* gsl_sort_vector_long.h */
static void dao__gsl_sort_vector_long( DaoContext *_ctx, DValue *_p[], int _n )
{
  gsl_vector_long* v= (gsl_vector_long*) DaoCData_CastData( _p[0]->v.cdata, dao_gsl_vector_long_Typer );

  gsl_sort_vector_long( v );
}
/* gsl_sort_vector_long.h */
static void dao__gsl_sort_vector_long_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  gsl_permutation* p= (gsl_permutation*) DaoCData_CastData( _p[0]->v.cdata, dao_gsl_permutation_Typer );
  gsl_vector_long* v= (gsl_vector_long*) DaoCData_CastData( _p[1]->v.cdata, dao_gsl_vector_long_Typer );

  int _gsl_sort_vector_long_index = gsl_sort_vector_long_index( p, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_long_index );
}
/* gsl_sort_vector_long.h */
static void dao__gsl_sort_vector_long_smallest( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* dest= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_long* v= (gsl_vector_long*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_long_Typer );

  int _gsl_sort_vector_long_smallest = gsl_sort_vector_long_smallest( dest, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_long_smallest );
}
/* gsl_sort_vector_long.h */
static void dao__gsl_sort_vector_long_largest( DaoContext *_ctx, DValue *_p[], int _n )
{
  long* dest= (long*) DaoArray_ToInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_long* v= (gsl_vector_long*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_long_Typer );

  int _gsl_sort_vector_long_largest = gsl_sort_vector_long_largest( dest, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_long_largest );
}
/* gsl_sort_vector_long.h */
static void dao__gsl_sort_vector_long_smallest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_long* v= (gsl_vector_long*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_long_Typer );

  int _gsl_sort_vector_long_smallest_index = gsl_sort_vector_long_smallest_index( p, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_long_smallest_index );
}
/* gsl_sort_vector_long.h */
static void dao__gsl_sort_vector_long_largest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_long* v= (gsl_vector_long*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_long_Typer );

  int _gsl_sort_vector_long_largest_index = gsl_sort_vector_long_largest_index( p, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_long_largest_index );
}
/* gsl_sort_vector_long_double.h */
static void dao__gsl_sort_vector_long_double( DaoContext *_ctx, DValue *_p[], int _n )
{
  gsl_vector_long_double* v= (gsl_vector_long_double*) DaoCData_CastData( _p[0]->v.cdata, dao_gsl_vector_long_double_Typer );

  gsl_sort_vector_long_double( v );
}
/* gsl_sort_vector_long_double.h */
static void dao__gsl_sort_vector_long_double_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  gsl_permutation* p= (gsl_permutation*) DaoCData_CastData( _p[0]->v.cdata, dao_gsl_permutation_Typer );
  gsl_vector_long_double* v= (gsl_vector_long_double*) DaoCData_CastData( _p[1]->v.cdata, dao_gsl_vector_long_double_Typer );

  int _gsl_sort_vector_long_double_index = gsl_sort_vector_long_double_index( p, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_long_double_index );
}
/* gsl_sort_vector_long_double.h */
static void dao__gsl_sort_vector_long_double_smallest( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* dest= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_long_double* v= (gsl_vector_long_double*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_long_double_Typer );

  int _gsl_sort_vector_long_double_smallest = gsl_sort_vector_long_double_smallest( dest, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_long_double_smallest );
}
/* gsl_sort_vector_long_double.h */
static void dao__gsl_sort_vector_long_double_largest( DaoContext *_ctx, DValue *_p[], int _n )
{
  long double* dest= (long double*) DaoArray_ToDouble( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_long_double* v= (gsl_vector_long_double*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_long_double_Typer );

  int _gsl_sort_vector_long_double_largest = gsl_sort_vector_long_double_largest( dest, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_long_double_largest );
}
/* gsl_sort_vector_long_double.h */
static void dao__gsl_sort_vector_long_double_smallest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_long_double* v= (gsl_vector_long_double*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_long_double_Typer );

  int _gsl_sort_vector_long_double_smallest_index = gsl_sort_vector_long_double_smallest_index( p, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_long_double_smallest_index );
}
/* gsl_sort_vector_long_double.h */
static void dao__gsl_sort_vector_long_double_largest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_long_double* v= (gsl_vector_long_double*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_long_double_Typer );

  int _gsl_sort_vector_long_double_largest_index = gsl_sort_vector_long_double_largest_index( p, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_long_double_largest_index );
}
/* gsl_sort_vector_short.h */
static void dao__gsl_sort_vector_short( DaoContext *_ctx, DValue *_p[], int _n )
{
  gsl_vector_short* v= (gsl_vector_short*) DaoCData_CastData( _p[0]->v.cdata, dao_gsl_vector_short_Typer );

  gsl_sort_vector_short( v );
}
/* gsl_sort_vector_short.h */
static void dao__gsl_sort_vector_short_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  gsl_permutation* p= (gsl_permutation*) DaoCData_CastData( _p[0]->v.cdata, dao_gsl_permutation_Typer );
  gsl_vector_short* v= (gsl_vector_short*) DaoCData_CastData( _p[1]->v.cdata, dao_gsl_vector_short_Typer );

  int _gsl_sort_vector_short_index = gsl_sort_vector_short_index( p, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_short_index );
}
/* gsl_sort_vector_short.h */
static void dao__gsl_sort_vector_short_smallest( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* dest= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_short* v= (gsl_vector_short*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_short_Typer );

  int _gsl_sort_vector_short_smallest = gsl_sort_vector_short_smallest( dest, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_short_smallest );
}
/* gsl_sort_vector_short.h */
static void dao__gsl_sort_vector_short_largest( DaoContext *_ctx, DValue *_p[], int _n )
{
  short* dest= (short*) DaoArray_ToShort( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_short* v= (gsl_vector_short*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_short_Typer );

  int _gsl_sort_vector_short_largest = gsl_sort_vector_short_largest( dest, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_short_largest );
}
/* gsl_sort_vector_short.h */
static void dao__gsl_sort_vector_short_smallest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_short* v= (gsl_vector_short*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_short_Typer );

  int _gsl_sort_vector_short_smallest_index = gsl_sort_vector_short_smallest_index( p, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_short_smallest_index );
}
/* gsl_sort_vector_short.h */
static void dao__gsl_sort_vector_short_largest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_short* v= (gsl_vector_short*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_short_Typer );

  int _gsl_sort_vector_short_largest_index = gsl_sort_vector_short_largest_index( p, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_short_largest_index );
}
/* gsl_sort_vector_uchar.h */
static void dao__gsl_sort_vector_uchar( DaoContext *_ctx, DValue *_p[], int _n )
{
  gsl_vector_uchar* v= (gsl_vector_uchar*) DaoCData_CastData( _p[0]->v.cdata, dao_gsl_vector_uchar_Typer );

  gsl_sort_vector_uchar( v );
}
/* gsl_sort_vector_uchar.h */
static void dao__gsl_sort_vector_uchar_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  gsl_permutation* p= (gsl_permutation*) DaoCData_CastData( _p[0]->v.cdata, dao_gsl_permutation_Typer );
  gsl_vector_uchar* v= (gsl_vector_uchar*) DaoCData_CastData( _p[1]->v.cdata, dao_gsl_vector_uchar_Typer );

  int _gsl_sort_vector_uchar_index = gsl_sort_vector_uchar_index( p, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_uchar_index );
}
/* gsl_sort_vector_uchar.h */
static void dao__gsl_sort_vector_uchar_smallest( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* dest= (unsigned char*) DString_GetMBS( _p[0]->v.s );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_uchar* v= (gsl_vector_uchar*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_uchar_Typer );

  int _gsl_sort_vector_uchar_smallest = gsl_sort_vector_uchar_smallest( dest, k, v );
  DString_SetMBS( _p[0]->v.s, (char*) dest );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_uchar_smallest );
}
/* gsl_sort_vector_uchar.h */
static void dao__gsl_sort_vector_uchar_largest( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned char* dest= (unsigned char*) DString_GetMBS( _p[0]->v.s );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_uchar* v= (gsl_vector_uchar*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_uchar_Typer );

  int _gsl_sort_vector_uchar_largest = gsl_sort_vector_uchar_largest( dest, k, v );
  DString_SetMBS( _p[0]->v.s, (char*) dest );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_uchar_largest );
}
/* gsl_sort_vector_uchar.h */
static void dao__gsl_sort_vector_uchar_smallest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_uchar* v= (gsl_vector_uchar*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_uchar_Typer );

  int _gsl_sort_vector_uchar_smallest_index = gsl_sort_vector_uchar_smallest_index( p, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_uchar_smallest_index );
}
/* gsl_sort_vector_uchar.h */
static void dao__gsl_sort_vector_uchar_largest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_uchar* v= (gsl_vector_uchar*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_uchar_Typer );

  int _gsl_sort_vector_uchar_largest_index = gsl_sort_vector_uchar_largest_index( p, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_uchar_largest_index );
}
/* gsl_sort_vector_uint.h */
static void dao__gsl_sort_vector_uint( DaoContext *_ctx, DValue *_p[], int _n )
{
  gsl_vector_uint* v= (gsl_vector_uint*) DaoCData_CastData( _p[0]->v.cdata, dao_gsl_vector_uint_Typer );

  gsl_sort_vector_uint( v );
}
/* gsl_sort_vector_uint.h */
static void dao__gsl_sort_vector_uint_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  gsl_permutation* p= (gsl_permutation*) DaoCData_CastData( _p[0]->v.cdata, dao_gsl_permutation_Typer );
  gsl_vector_uint* v= (gsl_vector_uint*) DaoCData_CastData( _p[1]->v.cdata, dao_gsl_vector_uint_Typer );

  int _gsl_sort_vector_uint_index = gsl_sort_vector_uint_index( p, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_uint_index );
}
/* gsl_sort_vector_uint.h */
static void dao__gsl_sort_vector_uint_smallest( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* dest= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_uint* v= (gsl_vector_uint*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_uint_Typer );

  int _gsl_sort_vector_uint_smallest = gsl_sort_vector_uint_smallest( dest, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_uint_smallest );
}
/* gsl_sort_vector_uint.h */
static void dao__gsl_sort_vector_uint_largest( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned int* dest= (unsigned int*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_uint* v= (gsl_vector_uint*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_uint_Typer );

  int _gsl_sort_vector_uint_largest = gsl_sort_vector_uint_largest( dest, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_uint_largest );
}
/* gsl_sort_vector_uint.h */
static void dao__gsl_sort_vector_uint_smallest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_uint* v= (gsl_vector_uint*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_uint_Typer );

  int _gsl_sort_vector_uint_smallest_index = gsl_sort_vector_uint_smallest_index( p, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_uint_smallest_index );
}
/* gsl_sort_vector_uint.h */
static void dao__gsl_sort_vector_uint_largest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_uint* v= (gsl_vector_uint*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_uint_Typer );

  int _gsl_sort_vector_uint_largest_index = gsl_sort_vector_uint_largest_index( p, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_uint_largest_index );
}
/* gsl_sort_vector_ulong.h */
static void dao__gsl_sort_vector_ulong( DaoContext *_ctx, DValue *_p[], int _n )
{
  gsl_vector_ulong* v= (gsl_vector_ulong*) DaoCData_CastData( _p[0]->v.cdata, dao_gsl_vector_ulong_Typer );

  gsl_sort_vector_ulong( v );
}
/* gsl_sort_vector_ulong.h */
static void dao__gsl_sort_vector_ulong_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  gsl_permutation* p= (gsl_permutation*) DaoCData_CastData( _p[0]->v.cdata, dao_gsl_permutation_Typer );
  gsl_vector_ulong* v= (gsl_vector_ulong*) DaoCData_CastData( _p[1]->v.cdata, dao_gsl_vector_ulong_Typer );

  int _gsl_sort_vector_ulong_index = gsl_sort_vector_ulong_index( p, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_ulong_index );
}
/* gsl_sort_vector_ulong.h */
static void dao__gsl_sort_vector_ulong_smallest( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* dest= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_ulong* v= (gsl_vector_ulong*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_ulong_Typer );

  int _gsl_sort_vector_ulong_smallest = gsl_sort_vector_ulong_smallest( dest, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_ulong_smallest );
}
/* gsl_sort_vector_ulong.h */
static void dao__gsl_sort_vector_ulong_largest( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned long* dest= (unsigned long*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_ulong* v= (gsl_vector_ulong*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_ulong_Typer );

  int _gsl_sort_vector_ulong_largest = gsl_sort_vector_ulong_largest( dest, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_ulong_largest );
}
/* gsl_sort_vector_ulong.h */
static void dao__gsl_sort_vector_ulong_smallest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_ulong* v= (gsl_vector_ulong*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_ulong_Typer );

  int _gsl_sort_vector_ulong_smallest_index = gsl_sort_vector_ulong_smallest_index( p, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_ulong_smallest_index );
}
/* gsl_sort_vector_ulong.h */
static void dao__gsl_sort_vector_ulong_largest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_ulong* v= (gsl_vector_ulong*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_ulong_Typer );

  int _gsl_sort_vector_ulong_largest_index = gsl_sort_vector_ulong_largest_index( p, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_ulong_largest_index );
}
/* gsl_sort_vector_ushort.h */
static void dao__gsl_sort_vector_ushort( DaoContext *_ctx, DValue *_p[], int _n )
{
  gsl_vector_ushort* v= (gsl_vector_ushort*) DaoCData_CastData( _p[0]->v.cdata, dao_gsl_vector_ushort_Typer );

  gsl_sort_vector_ushort( v );
}
/* gsl_sort_vector_ushort.h */
static void dao__gsl_sort_vector_ushort_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  gsl_permutation* p= (gsl_permutation*) DaoCData_CastData( _p[0]->v.cdata, dao_gsl_permutation_Typer );
  gsl_vector_ushort* v= (gsl_vector_ushort*) DaoCData_CastData( _p[1]->v.cdata, dao_gsl_vector_ushort_Typer );

  int _gsl_sort_vector_ushort_index = gsl_sort_vector_ushort_index( p, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_ushort_index );
}
/* gsl_sort_vector_ushort.h */
static void dao__gsl_sort_vector_ushort_smallest( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* dest= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_ushort* v= (gsl_vector_ushort*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_ushort_Typer );

  int _gsl_sort_vector_ushort_smallest = gsl_sort_vector_ushort_smallest( dest, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_ushort_smallest );
}
/* gsl_sort_vector_ushort.h */
static void dao__gsl_sort_vector_ushort_largest( DaoContext *_ctx, DValue *_p[], int _n )
{
  unsigned short* dest= (unsigned short*) DaoArray_ToUShort( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_ushort* v= (gsl_vector_ushort*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_ushort_Typer );

  int _gsl_sort_vector_ushort_largest = gsl_sort_vector_ushort_largest( dest, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_ushort_largest );
}
/* gsl_sort_vector_ushort.h */
static void dao__gsl_sort_vector_ushort_smallest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_ushort* v= (gsl_vector_ushort*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_ushort_Typer );

  int _gsl_sort_vector_ushort_smallest_index = gsl_sort_vector_ushort_smallest_index( p, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_ushort_smallest_index );
}
/* gsl_sort_vector_ushort.h */
static void dao__gsl_sort_vector_ushort_largest_index( DaoContext *_ctx, DValue *_p[], int _n )
{
  size_t* p= (size_t*) DaoArray_ToUInt( _p[0]->v.array );
  size_t k= (size_t) _p[1]->v.i;
  gsl_vector_ushort* v= (gsl_vector_ushort*) DaoCData_CastData( _p[2]->v.cdata, dao_gsl_vector_ushort_Typer );

  int _gsl_sort_vector_ushort_largest_index = gsl_sort_vector_ushort_largest_index( p, k, v );
  DaoContext_PutInteger( _ctx, (int) _gsl_sort_vector_ushort_largest_index );
}

int DaoOnLoad( DaoVmSpace *vms, DaoNameSpace *ns )
{
  DaoTypeBase *typers[107];
  const char *aliases[1];
  __daoVmSpace = vms;
  typers[0] = dao__gsl_matrix_char_const_view_Typer,
  typers[1] = dao__gsl_matrix_char_view_Typer,
  typers[2] = dao__gsl_matrix_complex_const_view_Typer,
  typers[3] = dao__gsl_matrix_complex_float_const_view_Typer,
  typers[4] = dao__gsl_matrix_complex_float_view_Typer,
  typers[5] = dao__gsl_matrix_complex_long_double_const_view_Typer,
  typers[6] = dao__gsl_matrix_complex_long_double_view_Typer,
  typers[7] = dao__gsl_matrix_complex_view_Typer,
  typers[8] = dao__gsl_matrix_const_view_Typer,
  typers[9] = dao__gsl_matrix_float_const_view_Typer,
  typers[10] = dao__gsl_matrix_float_view_Typer,
  typers[11] = dao__gsl_matrix_int_const_view_Typer,
  typers[12] = dao__gsl_matrix_int_view_Typer,
  typers[13] = dao__gsl_matrix_long_const_view_Typer,
  typers[14] = dao__gsl_matrix_long_double_const_view_Typer,
  typers[15] = dao__gsl_matrix_long_double_view_Typer,
  typers[16] = dao__gsl_matrix_long_view_Typer,
  typers[17] = dao__gsl_matrix_short_const_view_Typer,
  typers[18] = dao__gsl_matrix_short_view_Typer,
  typers[19] = dao__gsl_matrix_uchar_const_view_Typer,
  typers[20] = dao__gsl_matrix_uchar_view_Typer,
  typers[21] = dao__gsl_matrix_uint_const_view_Typer,
  typers[22] = dao__gsl_matrix_uint_view_Typer,
  typers[23] = dao__gsl_matrix_ulong_const_view_Typer,
  typers[24] = dao__gsl_matrix_ulong_view_Typer,
  typers[25] = dao__gsl_matrix_ushort_const_view_Typer,
  typers[26] = dao__gsl_matrix_ushort_view_Typer,
  typers[27] = dao__gsl_matrix_view_Typer,
  typers[28] = dao__gsl_vector_char_const_view_Typer,
  typers[29] = dao__gsl_vector_char_view_Typer,
  typers[30] = dao__gsl_vector_complex_const_view_Typer,
  typers[31] = dao__gsl_vector_complex_float_const_view_Typer,
  typers[32] = dao__gsl_vector_complex_float_view_Typer,
  typers[33] = dao__gsl_vector_complex_long_double_const_view_Typer,
  typers[34] = dao__gsl_vector_complex_long_double_view_Typer,
  typers[35] = dao__gsl_vector_complex_view_Typer,
  typers[36] = dao__gsl_vector_const_view_Typer,
  typers[37] = dao__gsl_vector_float_const_view_Typer,
  typers[38] = dao__gsl_vector_float_view_Typer,
  typers[39] = dao__gsl_vector_int_const_view_Typer,
  typers[40] = dao__gsl_vector_int_view_Typer,
  typers[41] = dao__gsl_vector_long_const_view_Typer,
  typers[42] = dao__gsl_vector_long_double_const_view_Typer,
  typers[43] = dao__gsl_vector_long_double_view_Typer,
  typers[44] = dao__gsl_vector_long_view_Typer,
  typers[45] = dao__gsl_vector_short_const_view_Typer,
  typers[46] = dao__gsl_vector_short_view_Typer,
  typers[47] = dao__gsl_vector_uchar_const_view_Typer,
  typers[48] = dao__gsl_vector_uchar_view_Typer,
  typers[49] = dao__gsl_vector_uint_const_view_Typer,
  typers[50] = dao__gsl_vector_uint_view_Typer,
  typers[51] = dao__gsl_vector_ulong_const_view_Typer,
  typers[52] = dao__gsl_vector_ulong_view_Typer,
  typers[53] = dao__gsl_vector_ushort_const_view_Typer,
  typers[54] = dao__gsl_vector_ushort_view_Typer,
  typers[55] = dao__gsl_vector_view_Typer,
  typers[56] = dao_gsl_block_Typer,
  typers[57] = dao_gsl_block_char_Typer,
  typers[58] = dao_gsl_block_complex_Typer,
  typers[59] = dao_gsl_block_complex_float_Typer,
  typers[60] = dao_gsl_block_complex_long_double_Typer,
  typers[61] = dao_gsl_block_float_Typer,
  typers[62] = dao_gsl_block_int_Typer,
  typers[63] = dao_gsl_block_long_Typer,
  typers[64] = dao_gsl_block_long_double_Typer,
  typers[65] = dao_gsl_block_short_Typer,
  typers[66] = dao_gsl_block_uchar_Typer,
  typers[67] = dao_gsl_block_uint_Typer,
  typers[68] = dao_gsl_block_ulong_Typer,
  typers[69] = dao_gsl_block_ushort_Typer,
  typers[70] = dao_gsl_complex_Typer,
  typers[71] = dao_gsl_complex_float_Typer,
  typers[72] = dao_gsl_complex_long_double_Typer,
  typers[73] = dao_gsl_error_handler_t_Typer,
  typers[74] = dao_gsl_ieee_double_rep_Typer,
  typers[75] = dao_gsl_ieee_float_rep_Typer,
  typers[76] = dao_gsl_matrix_Typer,
  typers[77] = dao_gsl_matrix_char_Typer,
  typers[78] = dao_gsl_matrix_complex_Typer,
  typers[79] = dao_gsl_matrix_complex_float_Typer,
  typers[80] = dao_gsl_matrix_complex_long_double_Typer,
  typers[81] = dao_gsl_matrix_float_Typer,
  typers[82] = dao_gsl_matrix_int_Typer,
  typers[83] = dao_gsl_matrix_long_Typer,
  typers[84] = dao_gsl_matrix_long_double_Typer,
  typers[85] = dao_gsl_matrix_short_Typer,
  typers[86] = dao_gsl_matrix_uchar_Typer,
  typers[87] = dao_gsl_matrix_uint_Typer,
  typers[88] = dao_gsl_matrix_ulong_Typer,
  typers[89] = dao_gsl_matrix_ushort_Typer,
  typers[90] = dao_gsl_permutation_Typer,
  typers[91] = dao_gsl_stream_handler_t_Typer,
  typers[92] = dao_gsl_vector_Typer,
  typers[93] = dao_gsl_vector_char_Typer,
  typers[94] = dao_gsl_vector_complex_Typer,
  typers[95] = dao_gsl_vector_complex_float_Typer,
  typers[96] = dao_gsl_vector_complex_long_double_Typer,
  typers[97] = dao_gsl_vector_float_Typer,
  typers[98] = dao_gsl_vector_int_Typer,
  typers[99] = dao_gsl_vector_long_Typer,
  typers[100] = dao_gsl_vector_long_double_Typer,
  typers[101] = dao_gsl_vector_short_Typer,
  typers[102] = dao_gsl_vector_uchar_Typer,
  typers[103] = dao_gsl_vector_uint_Typer,
  typers[104] = dao_gsl_vector_ulong_Typer,
  typers[105] = dao_gsl_vector_ushort_Typer,
  typers[106] = NULL;
  aliases[0] = NULL;
  DaoNameSpace_TypeDefine( ns, "double", "gsl_complex_packed" );
  DaoNameSpace_TypeDefine( ns, "double", "gsl_complex_packed_array" );
  DaoNameSpace_TypeDefine( ns, "double", "gsl_complex_packed_array_long_double" );
  DaoNameSpace_TypeDefine( ns, "double", "gsl_complex_packed_long_double" );
  DaoNameSpace_TypeDefine( ns, "double", "gsl_complex_packed_long_double_ptr" );
  DaoNameSpace_TypeDefine( ns, "double", "gsl_complex_packed_ptr" );
  DaoNameSpace_TypeDefine( ns, "float", "gsl_complex_packed_array_float" );
  DaoNameSpace_TypeDefine( ns, "float", "gsl_complex_packed_float" );
  DaoNameSpace_TypeDefine( ns, "float", "gsl_complex_packed_float_ptr" );
  DaoNameSpace_TypeDefine( ns, "int", "gsl_mode_t" );
  DaoNameSpace_TypeDefine( ns, "int", "gsl_prec_t" );
  DaoNameSpace_AddConstNumbers( ns, constNumbers );
  DaoNameSpace_WrapTypes( ns, typers );
  DaoNameSpace_WrapFunctions( ns, dao_Funcs );
  return 0;
}
#ifdef __cplusplus
}
#endif

